package com.example.onlinemonitoring.model;

import com.example.onlinemonitoring.model.common.sensor;
import java.util.Date;
import javax.persistence.*;

public class Dlqjxtxhistory extends sensor {
    /**
     * dlqjxtx传感器的编号。主键。自动递增。
     */
    @Id
    private Long id;

    /**
     * 外键。变电站的编号。
     */
    private Integer stationid;

    /**
     * 设备组
     */
    private Integer devicegroup;

    /**
     * 设备地址。传感器的站号。
     */
    private Integer deviceaddr;

    private Date datatime;

    /**
     * 监测点的名称。
     */
    private String pointname;

    /**
     * 合闸时间
     */
    private Float closingtime;

    /**
     * 合闸速度
     */
    private Float closingspeed;

    /**
     * 合闸线圈峰值(最大)电流
     */
    private Float closingmaxcurrent;

    /**
     * 合闸线圈平均电流
     */
    private Float closingavecurrent;

    /**
     * 合闸前一次有效电流
     */
    private Float closingeffcurrent;

    /**
     * 分闸时间
     */
    private Float openingtime;

    /**
     * 分闸速度
     */
    private Float openingspeed;

    /**
     * 分闸线圈峰值(最大)电流
     */
    private Float openingmaxcurrent;

    /**
     * 分闸线圈平均电流
     */
    private Float openingavecurrent;

    /**
     * 分闸前一次有效电流
     */
    private Float openingeffcurrent;

    /**
     * 储能时间
     */
    private Float storagetime;

    /**
     * 储能电机峰值(最大)电流
     */
    private Float storagemaxcurrent;

    /**
     * 储能电机平均电流
     */
    private Float storageavecurrent;

    /**
     * 断路器分合状态
     */
    private Integer openorclose;

    /**
     * 断路器储能状态
     */
    private Integer storage;

    /**
     * 合闸回路状态
     */
    private Integer closingcircuit;

    /**
     * 分闸回路状态
     */
    private Integer openingcircuit;

    /**
     * 断路器合闸次数
     */
    private Integer closingcount;

    /**
     * 合闸发生时间
     */
    private Date closingdate;

    /**
     * 断路器分闸次数
     */
    private Integer openingcount;

    /**
     * 分闸发生时间
     */
    private Date openingdate;

    /**
     * 断路器储能次数
     */
    private Integer storagecount;

    /**
     * 储能发生时间
     */
    private Date storagedate;

    /**
     * 判断数据是否变化的标志，通过对比上次拼接数据字符串来判断是否变化
     */
    private String memo;

    /**
     * 前端显示哪些字段
     */
    private String style;

    /**
     * 该监测点是否要用到
     */
    private Integer inuse;

    /**
     * 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    private Integer alarmlevel;

    /**
     * 上次报警消息。
     */
    private String alarmmessage;

    /**
     * 获取dlqjxtx传感器的编号。主键。自动递增。
     *
     * @return id - dlqjxtx传感器的编号。主键。自动递增。
     */
    public Long getId() {
        return id;
    }

    /**
     * 设置dlqjxtx传感器的编号。主键。自动递增。
     *
     * @param id dlqjxtx传感器的编号。主键。自动递增。
     */
    public void setId(Long id) {
        this.id = id;
    }

    /**
     * 获取外键。变电站的编号。
     *
     * @return stationid - 外键。变电站的编号。
     */
    public Integer getStationid() {
        return stationid;
    }

    /**
     * 设置外键。变电站的编号。
     *
     * @param stationid 外键。变电站的编号。
     */
    public void setStationid(Integer stationid) {
        this.stationid = stationid;
    }

    /**
     * 获取设备组
     *
     * @return devicegroup - 设备组
     */
    public Integer getDevicegroup() {
        return devicegroup;
    }

    /**
     * 设置设备组
     *
     * @param devicegroup 设备组
     */
    public void setDevicegroup(Integer devicegroup) {
        this.devicegroup = devicegroup;
    }

    /**
     * 获取设备地址。传感器的站号。
     *
     * @return deviceaddr - 设备地址。传感器的站号。
     */
    public Integer getDeviceaddr() {
        return deviceaddr;
    }

    /**
     * 设置设备地址。传感器的站号。
     *
     * @param deviceaddr 设备地址。传感器的站号。
     */
    public void setDeviceaddr(Integer deviceaddr) {
        this.deviceaddr = deviceaddr;
    }

    /**
     * @return datatime
     */
    public Date getDatatime() {
        return datatime;
    }

    /**
     * @param datatime
     */
    public void setDatatime(Date datatime) {
        this.datatime = datatime;
    }

    /**
     * 获取监测点的名称。
     *
     * @return pointname - 监测点的名称。
     */
    public String getPointname() {
        return pointname;
    }

    /**
     * 设置监测点的名称。
     *
     * @param pointname 监测点的名称。
     */
    public void setPointname(String pointname) {
        this.pointname = pointname;
    }

    /**
     * 获取合闸时间
     *
     * @return closingtime - 合闸时间
     */
    public Float getClosingtime() {
        return closingtime;
    }

    /**
     * 设置合闸时间
     *
     * @param closingtime 合闸时间
     */
    public void setClosingtime(Float closingtime) {
        this.closingtime = closingtime;
    }

    /**
     * 获取合闸速度
     *
     * @return closingspeed - 合闸速度
     */
    public Float getClosingspeed() {
        return closingspeed;
    }

    /**
     * 设置合闸速度
     *
     * @param closingspeed 合闸速度
     */
    public void setClosingspeed(Float closingspeed) {
        this.closingspeed = closingspeed;
    }

    /**
     * 获取合闸线圈峰值(最大)电流
     *
     * @return closingmaxcurrent - 合闸线圈峰值(最大)电流
     */
    public Float getClosingmaxcurrent() {
        return closingmaxcurrent;
    }

    /**
     * 设置合闸线圈峰值(最大)电流
     *
     * @param closingmaxcurrent 合闸线圈峰值(最大)电流
     */
    public void setClosingmaxcurrent(Float closingmaxcurrent) {
        this.closingmaxcurrent = closingmaxcurrent;
    }

    /**
     * 获取合闸线圈平均电流
     *
     * @return closingavecurrent - 合闸线圈平均电流
     */
    public Float getClosingavecurrent() {
        return closingavecurrent;
    }

    /**
     * 设置合闸线圈平均电流
     *
     * @param closingavecurrent 合闸线圈平均电流
     */
    public void setClosingavecurrent(Float closingavecurrent) {
        this.closingavecurrent = closingavecurrent;
    }

    /**
     * 获取合闸前一次有效电流
     *
     * @return closingeffcurrent - 合闸前一次有效电流
     */
    public Float getClosingeffcurrent() {
        return closingeffcurrent;
    }

    /**
     * 设置合闸前一次有效电流
     *
     * @param closingeffcurrent 合闸前一次有效电流
     */
    public void setClosingeffcurrent(Float closingeffcurrent) {
        this.closingeffcurrent = closingeffcurrent;
    }

    /**
     * 获取分闸时间
     *
     * @return openingtime - 分闸时间
     */
    public Float getOpeningtime() {
        return openingtime;
    }

    /**
     * 设置分闸时间
     *
     * @param openingtime 分闸时间
     */
    public void setOpeningtime(Float openingtime) {
        this.openingtime = openingtime;
    }

    /**
     * 获取分闸速度
     *
     * @return openingspeed - 分闸速度
     */
    public Float getOpeningspeed() {
        return openingspeed;
    }

    /**
     * 设置分闸速度
     *
     * @param openingspeed 分闸速度
     */
    public void setOpeningspeed(Float openingspeed) {
        this.openingspeed = openingspeed;
    }

    /**
     * 获取分闸线圈峰值(最大)电流
     *
     * @return openingmaxcurrent - 分闸线圈峰值(最大)电流
     */
    public Float getOpeningmaxcurrent() {
        return openingmaxcurrent;
    }

    /**
     * 设置分闸线圈峰值(最大)电流
     *
     * @param openingmaxcurrent 分闸线圈峰值(最大)电流
     */
    public void setOpeningmaxcurrent(Float openingmaxcurrent) {
        this.openingmaxcurrent = openingmaxcurrent;
    }

    /**
     * 获取分闸线圈平均电流
     *
     * @return openingavecurrent - 分闸线圈平均电流
     */
    public Float getOpeningavecurrent() {
        return openingavecurrent;
    }

    /**
     * 设置分闸线圈平均电流
     *
     * @param openingavecurrent 分闸线圈平均电流
     */
    public void setOpeningavecurrent(Float openingavecurrent) {
        this.openingavecurrent = openingavecurrent;
    }

    /**
     * 获取分闸前一次有效电流
     *
     * @return openingeffcurrent - 分闸前一次有效电流
     */
    public Float getOpeningeffcurrent() {
        return openingeffcurrent;
    }

    /**
     * 设置分闸前一次有效电流
     *
     * @param openingeffcurrent 分闸前一次有效电流
     */
    public void setOpeningeffcurrent(Float openingeffcurrent) {
        this.openingeffcurrent = openingeffcurrent;
    }

    /**
     * 获取储能时间
     *
     * @return storagetime - 储能时间
     */
    public Float getStoragetime() {
        return storagetime;
    }

    /**
     * 设置储能时间
     *
     * @param storagetime 储能时间
     */
    public void setStoragetime(Float storagetime) {
        this.storagetime = storagetime;
    }

    /**
     * 获取储能电机峰值(最大)电流
     *
     * @return storagemaxcurrent - 储能电机峰值(最大)电流
     */
    public Float getStoragemaxcurrent() {
        return storagemaxcurrent;
    }

    /**
     * 设置储能电机峰值(最大)电流
     *
     * @param storagemaxcurrent 储能电机峰值(最大)电流
     */
    public void setStoragemaxcurrent(Float storagemaxcurrent) {
        this.storagemaxcurrent = storagemaxcurrent;
    }

    /**
     * 获取储能电机平均电流
     *
     * @return storageavecurrent - 储能电机平均电流
     */
    public Float getStorageavecurrent() {
        return storageavecurrent;
    }

    /**
     * 设置储能电机平均电流
     *
     * @param storageavecurrent 储能电机平均电流
     */
    public void setStorageavecurrent(Float storageavecurrent) {
        this.storageavecurrent = storageavecurrent;
    }

    /**
     * 获取断路器分合状态
     *
     * @return openorclose - 断路器分合状态
     */
    public Integer getOpenorclose() {
        return openorclose;
    }

    /**
     * 设置断路器分合状态
     *
     * @param openorclose 断路器分合状态
     */
    public void setOpenorclose(Integer openorclose) {
        this.openorclose = openorclose;
    }

    /**
     * 获取断路器储能状态
     *
     * @return storage - 断路器储能状态
     */
    public Integer getStorage() {
        return storage;
    }

    /**
     * 设置断路器储能状态
     *
     * @param storage 断路器储能状态
     */
    public void setStorage(Integer storage) {
        this.storage = storage;
    }

    /**
     * 获取合闸回路状态
     *
     * @return closingcircuit - 合闸回路状态
     */
    public Integer getClosingcircuit() {
        return closingcircuit;
    }

    /**
     * 设置合闸回路状态
     *
     * @param closingcircuit 合闸回路状态
     */
    public void setClosingcircuit(Integer closingcircuit) {
        this.closingcircuit = closingcircuit;
    }

    /**
     * 获取分闸回路状态
     *
     * @return openingcircuit - 分闸回路状态
     */
    public Integer getOpeningcircuit() {
        return openingcircuit;
    }

    /**
     * 设置分闸回路状态
     *
     * @param openingcircuit 分闸回路状态
     */
    public void setOpeningcircuit(Integer openingcircuit) {
        this.openingcircuit = openingcircuit;
    }

    /**
     * 获取断路器合闸次数
     *
     * @return closingcount - 断路器合闸次数
     */
    public Integer getClosingcount() {
        return closingcount;
    }

    /**
     * 设置断路器合闸次数
     *
     * @param closingcount 断路器合闸次数
     */
    public void setClosingcount(Integer closingcount) {
        this.closingcount = closingcount;
    }

    /**
     * 获取合闸发生时间
     *
     * @return closingdate - 合闸发生时间
     */
    public Date getClosingdate() {
        return closingdate;
    }

    /**
     * 设置合闸发生时间
     *
     * @param closingdate 合闸发生时间
     */
    public void setClosingdate(Date closingdate) {
        this.closingdate = closingdate;
    }

    /**
     * 获取断路器分闸次数
     *
     * @return openingcount - 断路器分闸次数
     */
    public Integer getOpeningcount() {
        return openingcount;
    }

    /**
     * 设置断路器分闸次数
     *
     * @param openingcount 断路器分闸次数
     */
    public void setOpeningcount(Integer openingcount) {
        this.openingcount = openingcount;
    }

    /**
     * 获取分闸发生时间
     *
     * @return openingdate - 分闸发生时间
     */
    public Date getOpeningdate() {
        return openingdate;
    }

    /**
     * 设置分闸发生时间
     *
     * @param openingdate 分闸发生时间
     */
    public void setOpeningdate(Date openingdate) {
        this.openingdate = openingdate;
    }

    /**
     * 获取断路器储能次数
     *
     * @return storagecount - 断路器储能次数
     */
    public Integer getStoragecount() {
        return storagecount;
    }

    /**
     * 设置断路器储能次数
     *
     * @param storagecount 断路器储能次数
     */
    public void setStoragecount(Integer storagecount) {
        this.storagecount = storagecount;
    }

    /**
     * 获取储能发生时间
     *
     * @return storagedate - 储能发生时间
     */
    public Date getStoragedate() {
        return storagedate;
    }

    /**
     * 设置储能发生时间
     *
     * @param storagedate 储能发生时间
     */
    public void setStoragedate(Date storagedate) {
        this.storagedate = storagedate;
    }

    /**
     * 获取判断数据是否变化的标志，通过对比上次拼接数据字符串来判断是否变化
     *
     * @return memo - 判断数据是否变化的标志，通过对比上次拼接数据字符串来判断是否变化
     */
    public String getMemo() {
        return memo;
    }

    /**
     * 设置判断数据是否变化的标志，通过对比上次拼接数据字符串来判断是否变化
     *
     * @param memo 判断数据是否变化的标志，通过对比上次拼接数据字符串来判断是否变化
     */
    public void setMemo(String memo) {
        this.memo = memo;
    }

    /**
     * 获取前端显示哪些字段
     *
     * @return style - 前端显示哪些字段
     */
    public String getStyle() {
        return style;
    }

    /**
     * 设置前端显示哪些字段
     *
     * @param style 前端显示哪些字段
     */
    public void setStyle(String style) {
        this.style = style;
    }

    /**
     * 获取该监测点是否要用到
     *
     * @return inuse - 该监测点是否要用到
     */
    public Integer getInuse() {
        return inuse;
    }

    /**
     * 设置该监测点是否要用到
     *
     * @param inuse 该监测点是否要用到
     */
    public void setInuse(Integer inuse) {
        this.inuse = inuse;
    }

    /**
     * 获取报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     *
     * @return alarmlevel - 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    public Integer getAlarmlevel() {
        return alarmlevel;
    }

    /**
     * 设置报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     *
     * @param alarmlevel 报警等级。最新一条数据。\\\\\\\\n0=正常，1=预警(黄色)，2=报警(红色)
     */
    public void setAlarmlevel(Integer alarmlevel) {
        this.alarmlevel = alarmlevel;
    }

    /**
     * 获取上次报警消息。
     *
     * @return alarmmessage - 上次报警消息。
     */
    public String getAlarmmessage() {
        return alarmmessage;
    }

    /**
     * 设置上次报警消息。
     *
     * @param alarmmessage 上次报警消息。
     */
    public void setAlarmmessage(String alarmmessage) {
        this.alarmmessage = alarmmessage;
    }
}